home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume4 / dragon / patch1.2 < prev    next >
Encoding:
Internet Message Format  |  1989-05-23  |  32.7 KB
  1. Path: uunet!island!argv
  2. From: argv@island.uu.net (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v04i006:  Dragon, Patch1 (Part2)
  5. Message-ID: <767@island.uu.net>
  6. Date: 24 May 89 07:40:49 GMT
  7. Organization: Island Graphics, Marin County, California
  8. Lines: 1001
  9. Approved: island!argv@sun.com
  10.  
  11. Submitted-by: Gary Barnes <uunet!igor!amber!geb>
  12. Posting-number: Volume 4, Issue 6
  13. Archive-name: Dragon/patch1 (Part2)
  14.  
  15. *** ../dragon/Imakefile    Tue May 23 00:05:20 1989
  16. --- Imakefile    Mon May 22 23:55:26 1989
  17. ***************
  18. *** 1,7 ****
  19. !            SRCS = main.c board.c button.c icon.c tile.c tile_bits.c
  20. !            OBJS = main.o board.o button.o icon.o tile.o tile_bits.o
  21.          PROGRAMS = dragon
  22. !         DEFINES =
  23.          INCLUDES = 
  24.     SYS_LIBRARIES = -lXaw -lXmu -lXt -lX11
  25.   
  26. --- 1,8 ----
  27. !            SRCS = main.c board.c button.c draw.c icon.c tile.c tile_bits.c
  28. !            OBJS = main.o board.o button.o draw.o icon.o tile.o tile_bits.o
  29.          PROGRAMS = dragon
  30. !        LINTOPTS = -uxz
  31. !         DEFINES = -DWANTDEBUG
  32.          INCLUDES = 
  33.     SYS_LIBRARIES = -lXaw -lXmu -lXt -lX11
  34.   
  35. ***************
  36. *** 13,19 ****
  37. --- 14,27 ----
  38.           $(USRLIBDIR)/libXt.a \
  39.           $(USRLIBDIR)/libX11.a
  40.   
  41. + lint:
  42. +     $(LINT) $(LINTFLAGS) $(SRCS)
  43. + 
  44.   MakeBug:
  45.       cp Makefile MakeBug.bak
  46.       make -f MakeBug.bak Makefile
  47.       rm MakeBug.bak
  48. + 
  49. + tar:
  50. +     tar cf - . > ../dragon.tar
  51. +     compress -v ../dragon.tar
  52. *** ../dragon/Makefile    Tue May 23 00:05:21 1989
  53. --- Makefile    Mon May 22 23:55:28 1989
  54. ***************
  55. *** 1,4 ****
  56. !             TOP = /usr/src/X11R3
  57.           UTILSRC = $(TOP)/util
  58.          IMAKESRC = $(UTILSRC)/imake
  59.             IMAKE = $(IMAKESRC)/imake
  60. --- 1,4 ----
  61. !             TOP = /src/x
  62.           UTILSRC = $(TOP)/util
  63.          IMAKESRC = $(UTILSRC)/imake
  64.             IMAKE = $(IMAKESRC)/imake
  65. *** ../dragon/README    Tue May 23 00:03:36 1989
  66. --- README    Mon May 22 23:55:30 1989
  67. ***************
  68. *** 1,9 ****
  69. ! 04/19/89
  70.   
  71.   Dragon is a game.  It implements a version of the ancient game of Mah-Jongg.
  72.   
  73. ! Dragon is known to work on a Sun 3/60 running SunOS 3.5 with X11R3 from MIT.
  74. ! It compiles with the Sun compiler and with gcc version 1.31.
  75.   
  76.   As of this writing, the Athena Dialog widget has a bug that can cause Dragon
  77.   to get a segmentation/memory error.  There is code in X11R3/lib/Xaw/Dialog.c
  78. --- 1,24 ----
  79. ! 05/18/89
  80.   
  81.   Dragon is a game.  It implements a version of the ancient game of Mah-Jongg.
  82.   
  83. ! Dragon is known to work on a Sun 3/60 running SunOS 3.5 with X11R3 from
  84. ! MIT.  It compiles with the Sun compiler and with gcc version 1.31.
  85. ! 
  86. ! I have been told that the current version (this one right here) runs
  87. ! correctly on monochrome, gray-scale, and color DEC equipment.  Presumably
  88. ! it will run correctly on most servers at this point.
  89. ! 
  90. ! Dragon is a "monochrome" application; it uses two colors; the default
  91. ! "foreground" color and the default "background" color as defined and
  92. ! determined by the X Toolkit.
  93. ! 
  94. ! If you do a "make all" initially then the Makefile will be rebuilt using
  95. ! the MIT imake program.  If you do not have the MIT imake program (or don't
  96. ! want to use it) then rename the Makefile.Canned file to be Makefile and
  97. ! hand-edit it for use at your site.
  98. ! 
  99. ! 04/19/89
  100.   
  101.   As of this writing, the Athena Dialog widget has a bug that can cause Dragon
  102.   to get a segmentation/memory error.  There is code in X11R3/lib/Xaw/Dialog.c
  103. *** ../dragon/button.c    Tue May 23 00:04:00 1989
  104. --- button.c    Mon May 22 23:55:36 1989
  105. ***************
  106. *** 4,9 ****
  107. --- 4,12 ----
  108.   * Author: Gary E. Barnes    March 1989
  109.   *
  110.   * button.c - Deals with the command buttons on the board
  111. + ******************************************************************************
  112. + *  4/24/89 GEB     - When "Other" pressed, if "Samples" is on then turn it off
  113. + *        -  before changing button menus.
  114.   ******************************************************************************/
  115.   
  116.   #include "main.h"
  117. ***************
  118. *** 57,62 ****
  119. --- 60,66 ----
  120.       { "New Game",   New_Game,      FALSE   },
  121.       { "Restart",    Restart_Game, FALSE  },
  122.       { "Save",        Save_Game,    FALSE   },
  123. + #define OTHER_BUTTON 3
  124.       { "Other",        Other,      TRUE    },
  125.   
  126.       { "Hint",        Hints,      FALSE   },
  127. ***************
  128. *** 68,73 ****
  129. --- 72,78 ----
  130.   Button_Rec    Buttons2[NBUTTONS] = {
  131.       { "Redraw",        Redraw_All,      FALSE   },
  132.       { "Sides",        Sides,      FALSE   },
  133. + #define SAMPLES_BUTTON 2
  134.       { "Samples",    Show_Samples, TRUE    },
  135.       { "Other",        Other,      TRUE    },
  136.   
  137. ***************
  138. *** 107,114 ****
  139.   {
  140.   #undef SETARG
  141.   #define SETARG(name,value) \
  142. !     if (argi >= XtNumber(args)) {fprintf(stderr,"BS args overrun!\n");} \
  143. !     XtSetArg( args[argi], name,  value ); ++argi;
  144.   
  145.       Arg        args[10];
  146.       int        argi;
  147. --- 112,119 ----
  148.   {
  149.   #undef SETARG
  150.   #define SETARG(name,value) \
  151. !     DEBUG_ERROR(argi >= XtNumber(args),"BS args overrun!\n" ); \
  152. !     XtSetArg( args[argi], name,  (XtArgVal)value ); ++argi;
  153.   
  154.       Arg        args[10];
  155.       int        argi;
  156. ***************
  157. *** 218,226 ****
  158.       if (All_Buttons == &Buttons1[0]) {
  159.       All_Buttons = &Buttons2[0];
  160.       } else {
  161.       All_Buttons = &Buttons1[0];
  162.       }
  163. !     All_Buttons[3].hilite = !All_Buttons[3].hilite;
  164.       XClearArea( XtDisplay(Board), XtWindow(w),
  165.               0, 0, 0, (unsigned)(2*Tile_Height-Side_Y-Shadow_Y-1), FALSE );
  166.       Button_Expose( w, event, params, num_params );
  167. --- 223,236 ----
  168.       if (All_Buttons == &Buttons1[0]) {
  169.       All_Buttons = &Buttons2[0];
  170.       } else {
  171. +     /*--Turn off Samples mode if we are changing menus. */
  172. +     if (Buttons2[SAMPLES_BUTTON].hilite) {
  173. +         (*(Buttons2[SAMPLES_BUTTON].action))(w, event, params, num_params);
  174. +         Buttons2[SAMPLES_BUTTON].hilite = FALSE;
  175. +     }
  176.       All_Buttons = &Buttons1[0];
  177.       }
  178. !     All_Buttons[OTHER_BUTTON].hilite = !All_Buttons[OTHER_BUTTON].hilite;
  179.       XClearArea( XtDisplay(Board), XtWindow(w),
  180.               0, 0, 0, (unsigned)(2*Tile_Height-Side_Y-Shadow_Y-1), FALSE );
  181.       Button_Expose( w, event, params, num_params );
  182. ***************
  183. *** 259,266 ****
  184.       FILE    *file;
  185.   
  186.       DEBUG_CALL(Restore_Game);
  187. !     strcpy( &name[0], getenv( "HOME" ) );
  188. !     strcat( &name[0], "/.dragon-save" );
  189.       file = fopen( &name[0], "r" );
  190.       if (file == (FILE*)NULL) {
  191.       Complain( "Cannot open the $HOME/.dragon-save file." );
  192. --- 269,276 ----
  193.       FILE    *file;
  194.   
  195.       DEBUG_CALL(Restore_Game);
  196. !     (void)strcpy( &name[0], getenv( "HOME" ) );
  197. !     (void)strcat( &name[0], "/.dragon-save" );
  198.       file = fopen( &name[0], "r" );
  199.       if (file == (FILE*)NULL) {
  200.       Complain( "Cannot open the $HOME/.dragon-save file." );
  201. ***************
  202. *** 289,296 ****
  203.       FILE    *file;
  204.   
  205.       DEBUG_CALL(Save_Game);
  206. !     strcpy( &name[0], getenv( "HOME" ) );
  207. !     strcat( &name[0], "/.dragon-save" );
  208.       file = fopen( &name[0], "w" );
  209.       if (file == (FILE*)NULL) {
  210.       Complain( "Cannot open the $HOME/.dragon-save file." );
  211. --- 299,306 ----
  212.       FILE    *file;
  213.   
  214.       DEBUG_CALL(Save_Game);
  215. !     (void)strcpy( &name[0], getenv( "HOME" ) );
  216. !     (void)strcat( &name[0], "/.dragon-save" );
  217.       file = fopen( &name[0], "w" );
  218.       if (file == (FILE*)NULL) {
  219.       Complain( "Cannot open the $HOME/.dragon-save file." );
  220. ***************
  221. *** 401,408 ****
  222.           if (but[i].text == NULL) { goto Next_Button; }
  223.           l = strlen(but[i].text);
  224.           if (l > 8) {
  225. !         fprintf( stderr, "Button name too long: %s\n",
  226. !              but[i].text );
  227.           l = 8;
  228.           }
  229.           but[i].x = x;
  230. --- 411,418 ----
  231.           if (but[i].text == NULL) { goto Next_Button; }
  232.           l = strlen(but[i].text);
  233.           if (l > 8) {
  234. !         (void)fprintf( stderr, "Button name too long: %s\n",
  235. !                    but[i].text );
  236.           l = 8;
  237.           }
  238.           but[i].x = x;
  239. ***************
  240. *** 463,469 ****
  241.   * Called to draw the vector text in some button.
  242.   ******************************************************************************/
  243.   {
  244. !     static char pntserr[] = "DT pnts overflow!\n";
  245.       XPoint    pnts[50];
  246.       int        pnti;
  247.       int        h1;
  248. --- 473,481 ----
  249.   * Called to draw the vector text in some button.
  250.   ******************************************************************************/
  251.   {
  252. ! #ifdef WANTDEBUG
  253. !     static char *pntserr = "DT pnts overflow!\n";
  254. ! #endif
  255.       XPoint    pnts[50];
  256.       int        pnti;
  257.       int        h1;
  258. ***************
  259. *** 471,477 ****
  260.   
  261.   #undef PNT
  262.   #define PNT(X,Y) \
  263. !     if (pnti >= XtNumber(pnts)){fprintf(stderr,pntserr);} \
  264.       pnts[pnti].x = X; pnts[pnti].y = Y; ++pnti
  265.       ;
  266.   
  267. --- 483,489 ----
  268.   
  269.   #undef PNT
  270.   #define PNT(X,Y) \
  271. !     DEBUG_ERROR( pnti >= XtNumber(pnts), pntserr ); \
  272.       pnts[pnti].x = X; pnts[pnti].y = Y; ++pnti
  273.       ;
  274.   
  275. ***************
  276. *** 500,512 ****
  277.           PNT( 0,        h26    );
  278.           PNT( w6,    h6    );
  279.           PNT( w6,    h6    );
  280. !         PNT( 2*w6,    0    );
  281.           PNT( w6,    -h6    );
  282.           PNT( w6,    -h6    );
  283.           PNT( 0,        -h26    );
  284.           PNT( -w6,    -h6    );
  285.           PNT( -w6,    -h6    );
  286. !         PNT( -2*w6,    0    );
  287.           PNT( -w6,    h6    );
  288.           PNT( -w6,    h6    );
  289.           break;
  290. --- 512,524 ----
  291.           PNT( 0,        h26    );
  292.           PNT( w6,    h6    );
  293.           PNT( w6,    h6    );
  294. !         PNT( w1-4*w6,    0    );
  295.           PNT( w6,    -h6    );
  296.           PNT( w6,    -h6    );
  297.           PNT( 0,        -h26    );
  298.           PNT( -w6,    -h6    );
  299.           PNT( -w6,    -h6    );
  300. !         PNT( -(w1-4*w6),0    );
  301.           PNT( -w6,    h6    );
  302.           PNT( -w6,    h6    );
  303.           break;
  304. *** ../dragon/dragon.man    Tue May 23 00:03:54 1989
  305. --- dragon.man    Mon May 22 23:55:37 1989
  306. ***************
  307. *** 8,16 ****
  308. --- 8,18 ----
  309.   [-icongeometry geometry]
  310.   [-/+iconic]
  311.   [-iconname name]
  312. + [-geometry geometry]
  313.   [-/+reverse]
  314.   [-/+shadows]
  315.   [-sides type]
  316. + [-/+sticky]
  317.   .SH DESCRIPTION
  318.   \fIDragon\fP plays a version of the game of Mah-Jongg.
  319.   
  320. ***************
  321. *** 73,78 ****
  322. --- 75,85 ----
  323.   250 milliseconds.  Clicks further apart than this will be treated as
  324.   separate single clicks instead of one double click.
  325.   .TP 8
  326. + .B \-geometry geometry
  327. + Use this option to specify the geometry to be used for the
  328. + \fIdragon\fP window.  There are five sizes that \fIdragon\fP prefers,
  329. + 450x340, 650x500, 870x660, 1080x820, and 1290x980.
  330. + .TP 8
  331.   .B \-icongeometry geometry
  332.   Use this option to specify the geometry to be used for the
  333.   \fIdragon\fP icon.  There are two sizes that \fIdragon\fP prefers,
  334. ***************
  335. *** 97,102 ****
  336. --- 104,116 ----
  337.   .B \-sides type
  338.   This option can be used to specify the way that tile sides are drawn.
  339.   There are four possiblities.  "gray" (the default), "black", and "line".
  340. + .TP 8
  341. + .B \-sticky
  342. + By default, the first selection is "sticky" (+sticky) which means that
  343. + attempts to select a second tile that is free but which doesn't match
  344. + the first are rejected.  If the first selection is not sticky
  345. + (-sticky), an attempt to select a free tile that doesn't match the first
  346. + will deselect the first tile and leave only the second selected.
  347.   .SH MOUSE BUTTONS
  348.   Click button 1 on any tile to select it.  Click on any menu button to activate
  349.   it.
  350. ***************
  351. *** 176,181 ****
  352. --- 190,201 ----
  353.   Specifies the maximum time to allow between the two clicks that form a
  354.   double-click.  The default is 250.
  355.   .TP 8
  356. + .B "geometry (\fPclass\fB Geometry)"
  357. + Use this option to specify the geometry to be used for the
  358. + \fIdragon\fP window.  There are five sizes that \fIdragon\fP prefers,
  359. + 450x340, 650x500, 870x660, 1080x820, and 1290x980.  The default is
  360. + "450x340".
  361. + .TP 8
  362.   .B "iconGeometry (\fPclass\fB IconGeometry)"
  363.   Specifies the geometry of the \fIdragon\fB icon.  Preferred sizes are
  364.   32x32 and 64x64.  The default is "64x64".
  365. ***************
  366. *** 190,195 ****
  367. --- 210,219 ----
  368.   .B "reverseVideo (\fPclass\fB ReverseVideo)"
  369.   Specifies TRUE for reverse-video effects and FALSE for normal-video.
  370.   The default is FALSE.
  371. + .TP 8
  372. + .B "stickyTile \(fPclass\fB StickyTile)|
  373. + Specify TRUE for first tile selected to be sticky (default), FALSE for
  374. + selection follows click.
  375.   .TP 8
  376.   .B "tileShadows (\fPclass\fB TileShadows)"
  377.   Specifies TRUE if tiles are to have 3-D shadows and FALSE if not.  The
  378. *** ../dragon/icon.c    Tue May 23 00:04:01 1989
  379. --- icon.c    Mon May 22 23:55:41 1989
  380. ***************
  381. *** 13,19 ****
  382.   
  383.   extern char * malloc();
  384.   extern        free();
  385. - extern Pixmap XCreateTile();
  386.   
  387.   
  388.   GC    Icon_GC = (GC)0;        /* GC used for Icon window. */
  389. --- 13,18 ----
  390. ***************
  391. *** 58,70 ****
  392.    *  preexisting Icon images. */
  393.   
  394.       if (Icon_GC == (GC)0) {
  395. !     if (Dragon_Resources.Reverse_Video) {
  396. !         gcv.background = BlackPixelOfScreen(XtScreen(w));
  397. !         gcv.foreground = WhitePixelOfScreen(XtScreen(w));
  398. !     } else {
  399. !         gcv.foreground = BlackPixelOfScreen(XtScreen(w));
  400. !         gcv.background = WhitePixelOfScreen(XtScreen(w));
  401. !     }
  402.       Icon_GC = XtGetGC( w, GCForeground|GCBackground, &gcv );
  403.       }
  404.       ximage.height  = size;
  405. --- 57,64 ----
  406.    *  preexisting Icon images. */
  407.   
  408.       if (Icon_GC == (GC)0) {
  409. !     gcv.foreground = Dragon_Resources.Foreground;
  410. !     gcv.background = Dragon_Resources.Background;
  411.       Icon_GC = XtGetGC( w, GCForeground|GCBackground, &gcv );
  412.       }
  413.       ximage.height  = size;
  414. ***************
  415. *** 115,122 ****
  416.       int           scr;
  417.   
  418.   #define SETARG(name,value) \
  419. !     if (*argi >= argn) {fprintf(stderr,"IS args overrun!\n");} \
  420. !     XtSetArg( args[*argi], name,  value ); ++*argi;
  421.   
  422.   /*--If we've been asked to set up the Icon geometry then do that. */
  423.   
  424. --- 109,116 ----
  425.       int           scr;
  426.   
  427.   #define SETARG(name,value) \
  428. !     DEBUG_ERROR( *argi >= argn, "IS args overrun!\n" ); \
  429. !     XtSetArg( args[*argi], name,  (XtArgVal)value ); ++*argi;
  430.   
  431.   /*--If we've been asked to set up the Icon geometry then do that. */
  432.   
  433. ***************
  434. *** 172,183 ****
  435.               ic[i].min_height <= size &&
  436.               size-ic[i].min_height & ic[i].height_inc == 0) {
  437.               Icon_Pixmap =        /* Size is perfect */
  438. !               XCreateTile( XtDisplay(Dragon),
  439. !                    RootWindowOfScreen(XtScreen(Dragon)),
  440. !                    (size == 64
  441. !                     ? &dragon_icon64_bits[0]
  442. !                     : &dragon_icon32_bits[0]), 
  443. !                    size, size );
  444.           }
  445.           }
  446.           if (Icon_Pixmap != (Pixmap)NULL ||     /* Stop on success */
  447. --- 166,181 ----
  448.               ic[i].min_height <= size &&
  449.               size-ic[i].min_height & ic[i].height_inc == 0) {
  450.               Icon_Pixmap =        /* Size is perfect */
  451. !               XCreatePixmapFromBitmapData
  452. !             ( XtDisplay(Dragon),
  453. !               RootWindowOfScreen(XtScreen(Dragon)),
  454. !               (size == 64
  455. !                ? &dragon_icon64_bits[0]
  456. !                : &dragon_icon32_bits[0]), 
  457. !               (unsigned int)size, (unsigned int)size,
  458. !               Dragon_Resources.Foreground,
  459. !               Dragon_Resources.Background,
  460. !               DefaultDepthOfScreen(XtScreen(Dragon)) );
  461.           }
  462.           }
  463.           if (Icon_Pixmap != (Pixmap)NULL ||     /* Stop on success */
  464. ***************
  465. *** 193,199 ****
  466.           char    *data;
  467.           char    *orig;
  468.           char    *ptr;
  469. !         int         w, wb, h, hb;
  470.           int         inc;
  471.   
  472.   /*--Figure out which of our pixmaps we will copy into this odd pixmap. */
  473. --- 191,197 ----
  474.           char    *data;
  475.           char    *orig;
  476.           char    *ptr;
  477. !         unsigned int w, wb, h, hb;
  478.           int         inc;
  479.   
  480.   /*--Figure out which of our pixmaps we will copy into this odd pixmap. */
  481. ***************
  482. *** 235,243 ****
  483.   /*--Create the pixmap and free up the data area. */
  484.   
  485.           Icon_Pixmap =
  486. !           XCreateTile( XtDisplay(Dragon),
  487. !                RootWindowOfScreen(XtScreen(Dragon)),
  488. !                data, w, h );
  489.           free( data );
  490.       }
  491.       XFree( ic );
  492. --- 233,243 ----
  493.   /*--Create the pixmap and free up the data area. */
  494.   
  495.           Icon_Pixmap =
  496. !           XCreatePixmapFromBitmapData
  497. !         ( XtDisplay(Dragon), RootWindowOfScreen(XtScreen(Dragon)),
  498. !           data, w, h,
  499. !           Dragon_Resources.Foreground, Dragon_Resources.Background,
  500. !           DefaultDepthOfScreen(XtScreen(Dragon)) );
  501.           free( data );
  502.       }
  503.       XFree( ic );
  504. ***************
  505. *** 262,270 ****
  506.       Widget        Icon_Core;
  507.   
  508.   #define LCLARG(name,value) \
  509. !     if (SomeArgsi >= XtNumber(SomeArgs)) \
  510. !       {fprintf(stderr,"IS SomeArgs overrun!\n");} \
  511. !     XtSetArg( SomeArgs[SomeArgsi], name,  value ); ++SomeArgsi;
  512.           ;
  513.   
  514.   /*--Create a shell to contain the Icon window. */
  515. --- 262,270 ----
  516.       Widget        Icon_Core;
  517.   
  518.   #define LCLARG(name,value) \
  519. !     DEBUG_ERROR( SomeArgsi >= XtNumber(SomeArgs), \
  520. !              "IS SomeArgs overrun!\n" ); \
  521. !     XtSetArg( SomeArgs[SomeArgsi], name,  (XtArgVal)value ); ++SomeArgsi;
  522.           ;
  523.   
  524.   /*--Create a shell to contain the Icon window. */
  525. *** ../dragon/main.c    Tue May 23 00:04:03 1989
  526. --- main.c    Mon May 22 23:55:43 1989
  527. ***************
  528. *** 38,57 ****
  529.        XtRString, (caddr_t)default}
  530.   #define INT(name,class,field,default) \
  531.       {name, class, XtRInt, sizeof(int), offset(field), XtRInt, (caddr_t)default}
  532.   #define STRING(name,class,field,default) \
  533.       {name, class, XtRString, sizeof(String), offset(field), XtRString, \
  534.        (caddr_t)default}
  535.   
  536.   static XtResource dragon_resources[] = {
  537.     CURSOR ( "cursor",        XtCCursor,       Cursor,             "hand2"     ),
  538.     BOOLEAN( "debug",        "Debug",         Debug,         &def_FALSE  ),
  539.     INT    ( "doubleClick",   "DoubleClick",   Double_Click_Time,  &def_DCTime ),
  540. !   STRING ( XtNgeometry,     XtCGeometry,     Geometry,         "444x339"   ),
  541.     STRING ( "iconGeometry",  "IconGeometry",  Icon_Geometry,      "64x64"     ),
  542.     BOOLEAN( "iconic",        "Iconic",        Iconic,             &def_FALSE  ),
  543.     STRING ( XtNiconName,        XtCIconName,     Icon_Name,         NULL          ),
  544.     BOOLEAN( XtNreverseVideo, XtCReverseVideo, Reverse_Video,      &def_FALSE  ),
  545. !   BOOLEAN( "tileShadows",   "TileShadows",   Tile_Shadows,     &def_TRUE  ),
  546.     STRING ( "tileSides",        "TileSides",     Tile_Sides,     "gray"         ),
  547.   };
  548.   
  549. --- 38,65 ----
  550.        XtRString, (caddr_t)default}
  551.   #define INT(name,class,field,default) \
  552.       {name, class, XtRInt, sizeof(int), offset(field), XtRInt, (caddr_t)default}
  553. + #define PIXEL(name,class,field,default) \
  554. +     {name, class, XtRPixel, sizeof(Pixel), \
  555. +      offset(field), XtRString, (caddr_t)default}
  556.   #define STRING(name,class,field,default) \
  557.       {name, class, XtRString, sizeof(String), offset(field), XtRString, \
  558.        (caddr_t)default}
  559.   
  560.   static XtResource dragon_resources[] = {
  561. +   PIXEL  ( XtNbackground,   XtCBackground,   Background,
  562. +        XtExtdefaultbackground ),
  563.     CURSOR ( "cursor",        XtCCursor,       Cursor,             "hand2"     ),
  564.     BOOLEAN( "debug",        "Debug",         Debug,         &def_FALSE  ),
  565.     INT    ( "doubleClick",   "DoubleClick",   Double_Click_Time,  &def_DCTime ),
  566. !   PIXEL  ( XtNforeground,   XtCForeground,   Foreground,
  567. !        XtExtdefaultforeground ),
  568. !   STRING ( XtNgeometry,     XtCGeometry,     Geometry,         "450x340"   ),
  569.     STRING ( "iconGeometry",  "IconGeometry",  Icon_Geometry,      "64x64"     ),
  570.     BOOLEAN( "iconic",        "Iconic",        Iconic,             &def_FALSE  ),
  571.     STRING ( XtNiconName,        XtCIconName,     Icon_Name,         NULL          ),
  572.     BOOLEAN( XtNreverseVideo, XtCReverseVideo, Reverse_Video,      &def_FALSE  ),
  573. !   BOOLEAN( "stickyTile",    "StickyTile",    Sticky_Tile,     &def_TRUE   ),
  574. !   BOOLEAN( "tileShadows",   "TileShadows",   Tile_Shadows,     &def_TRUE   ),
  575.     STRING ( "tileSides",        "TileSides",     Tile_Sides,     "gray"         ),
  576.   };
  577.   
  578. ***************
  579. *** 80,85 ****
  580. --- 88,95 ----
  581.   {"-shadows",     ".tileShadows",     XrmoptionNoArg,   (caddr_t)"off"  },
  582.   {"+shadows",     ".tileShadows",     XrmoptionNoArg,   (caddr_t)"on" },
  583.   {"-sides",     ".tileSides",         XrmoptionSepArg,  (caddr_t)"line"},
  584. + {"-sticky",     ".stickyTile",      XrmoptionNoArg,   (caddr_t)"off" },
  585. + {"+sticky",     ".stickyTile",      XrmoptionNoArg,   (caddr_t)"on" },
  586.   };
  587.   
  588.   typedef struct {
  589. ***************
  590. *** 100,105 ****
  591. --- 110,116 ----
  592.   {"-/+reverse",         "turn on/off reverse video"},
  593.   {"-/+shadows",         "turn on/off tile shadows"},
  594.   {"-sides line/black/gray","set the style for tile sides"},
  595. + {"-/+sticky",         "first tile selected sticky"},
  596.   { NULL, NULL }
  597.   };
  598.   
  599. ***************
  600. *** 157,195 ****
  601.   } /* Command_Line_Help */
  602.   
  603.   
  604. - Pixmap XCreateTile( display, d, data, width, height )
  605. -      Display        *display;
  606. -      Drawable         d;
  607. -      char        *data;
  608. -      unsigned int    width, height;
  609. - /******************************************************************************
  610. - * Converted form of XCreatePixmapFromBitmapData.  Use our GC and don't bother
  611. - * the Server for another one.
  612. - ******************************************************************************/
  613. - {
  614. -     XImage ximage;
  615. -     Pixmap pix;
  616. - 
  617. -     pix = XCreatePixmap( display, d, width, height, 1 );
  618. -     if (pix == (Pixmap)0) return (Pixmap)0;
  619. - 
  620. -     ximage.height = height;
  621. -     ximage.width = width;
  622. -     ximage.depth = 1;
  623. -     ximage.xoffset = 0;
  624. -     ximage.format = XYBitmap;
  625. -     ximage.data = data;
  626. -     ximage.byte_order = LSBFirst;
  627. -     ximage.bitmap_unit = 8;
  628. -     ximage.bitmap_bit_order = LSBFirst;
  629. -     ximage.bitmap_pad = 8;
  630. -     ximage.bytes_per_line = (width+7)/8;
  631. - 
  632. -     XPutImage( display, pix, Normal_GC, &ximage, 0, 0, 0, 0, width, height );
  633. -     return pix;
  634. - } /* XCreateTile */
  635. - 
  636. - 
  637.   static void GC_Setup()
  638.   /******************************************************************************
  639.   * Set up the GC's that we will be using for drawing.
  640. --- 168,173 ----
  641. ***************
  642. *** 198,208 ****
  643.       XGCValues    gcv;
  644.       Pixel    pix;
  645.   
  646. ! /*--Xor_GC - fg = black, bg = white, func = xor */
  647.   
  648.       gcv.function = GXxor;
  649. !     gcv.foreground = BlackPixelOfScreen(XtScreen(Dragon));
  650. !     gcv.background = WhitePixelOfScreen(XtScreen(Dragon));
  651.       Xor_GC = XtGetGC( Dragon,
  652.                 GCFunction|GCForeground|GCBackground,
  653.                 &gcv );
  654. --- 176,187 ----
  655.       XGCValues    gcv;
  656.       Pixel    pix;
  657.   
  658. ! /*--Xor_GC - fg = black, bg = white, func = xor; flops colors between the
  659. !  *  foreground and the background when applied. */
  660.   
  661.       gcv.function = GXxor;
  662. !     gcv.foreground = Dragon_Resources.Foreground ^ Dragon_Resources.Background;
  663. !     gcv.background = (Pixel)0;    /* pixel value with all bits "off" */
  664.       Xor_GC = XtGetGC( Dragon,
  665.                 GCFunction|GCForeground|GCBackground,
  666.                 &gcv );
  667. ***************
  668. *** 210,227 ****
  669.   /*--Normal_GC - fg = black, bg = white, func = copy */
  670.   
  671.       gcv.function = GXcopy;
  672. !     if (Dragon_Resources.Reverse_Video) {
  673. !     gcv.background = BlackPixelOfScreen(XtScreen(Dragon));
  674. !     gcv.foreground = WhitePixelOfScreen(XtScreen(Dragon));
  675. !     }
  676.       Normal_GC = XtGetGC( Dragon, GCFunction|GCForeground|GCBackground, &gcv );
  677.   
  678.   /*--Gray_GC - fg = black, bg = white, func = copy, tile = Gray */
  679.   
  680. !     gcv.tile = XCreateTile( XtDisplay(Board), XtWindow(Board),
  681. !                 gray_bits, gray_width, gray_height );
  682. !     if (gcv.tile == None) {
  683. !     fprintf( stderr, "Can't allocate gray pixmap.\n" );
  684.       exit(1);
  685.       }
  686.       gcv.fill_style = FillTiled;
  687. --- 189,208 ----
  688.   /*--Normal_GC - fg = black, bg = white, func = copy */
  689.   
  690.       gcv.function = GXcopy;
  691. !     gcv.foreground = Dragon_Resources.Foreground;
  692. !     gcv.background = Dragon_Resources.Background;
  693.       Normal_GC = XtGetGC( Dragon, GCFunction|GCForeground|GCBackground, &gcv );
  694.   
  695.   /*--Gray_GC - fg = black, bg = white, func = copy, tile = Gray */
  696.   
  697. !     gcv.tile =
  698. !       XCreatePixmapFromBitmapData
  699. !     ( XtDisplay(Board), XtWindow(Board),
  700. !       gray_bits, gray_width, gray_height,
  701. !       Dragon_Resources.Foreground, Dragon_Resources.Background,
  702. !       DefaultDepthOfScreen(XtScreen(Board)) );
  703. !     if (gcv.tile == (Pixmap)0L) {
  704. !     (void)fprintf( stderr, "Can't allocate gray pixmap.\n" );
  705.       exit(1);
  706.       }
  707.       gcv.fill_style = FillTiled;
  708. ***************
  709. *** 229,259 ****
  710.                  GCFunction|GCForeground|GCBackground|GCTile|GCFillStyle,
  711.                  &gcv );
  712.   
  713. ! /*--Over_GC - fg = black, bg = white, func = or */
  714.   
  715. !     if (Dragon_Resources.Reverse_Video) {
  716. !     gcv.function = GXand;
  717. !     } else {
  718. !     gcv.function = GXor;
  719. !     }
  720. !     gcv.tile =
  721. !       XCreateTile( XtDisplay(Board), XtWindow(Board),
  722. !            shadow_bits, shadow_width, shadow_height );
  723. !     if (gcv.tile == None) {
  724. !     fprintf( stderr, "Can't allocate shadow pixmap.\n" );
  725.       exit(1);
  726.       }
  727. !     gcv.fill_style = FillTiled;
  728.       Over_GC = XtGetGC( Dragon,
  729. !                GCFunction|GCForeground|GCBackground|GCTile|GCFillStyle,
  730.                  &gcv );
  731.   
  732.   /*--Reverse_GC - fg = white, bg = black, func = copy */
  733.   
  734.       gcv.function = GXcopy;
  735. !     pix = gcv.background;
  736. !     gcv.background = gcv.foreground;
  737. !     gcv.foreground = pix;
  738.       Reverse_GC = XtGetGC( Dragon, GCFunction|GCForeground|GCBackground, &gcv );
  739.   
  740.   } /* GC_Setup */
  741. --- 210,237 ----
  742.                  GCFunction|GCForeground|GCBackground|GCTile|GCFillStyle,
  743.                  &gcv );
  744.   
  745. ! /*--Over_GC - fg = black xor white, bg = 0, func = copy */
  746.   
  747. !     gcv.function = GXcopy;
  748. !     gcv.stipple =        /* stipple operations are always depth 1 */
  749. !       XCreateBitmapFromData
  750. !     ( XtDisplay(Board), XtWindow(Board),
  751. !       shadow_bits, shadow_width, shadow_height );
  752. !     if (gcv.stipple == (Pixmap)0L) {
  753. !     (void)fprintf( stderr, "Can't allocate shadow pixmap.\n" );
  754.       exit(1);
  755.       }
  756. !     gcv.fill_style = FillStippled;
  757.       Over_GC = XtGetGC( Dragon,
  758. !                GCFunction|GCForeground|GCBackground|
  759. !                   GCStipple|GCFillStyle,
  760.                  &gcv );
  761.   
  762.   /*--Reverse_GC - fg = white, bg = black, func = copy */
  763.   
  764.       gcv.function = GXcopy;
  765. !     gcv.background = Dragon_Resources.Foreground;
  766. !     gcv.foreground = Dragon_Resources.Background;
  767.       Reverse_GC = XtGetGC( Dragon, GCFunction|GCForeground|GCBackground, &gcv );
  768.   
  769.   } /* GC_Setup */
  770. ***************
  771. *** 271,278 ****
  772.   
  773.   #undef SETARG
  774.   #define SETARG(name,value) \
  775. !     if (argi >= XtNumber(args)) {fprintf(stderr,"main, args overrun!\n");} \
  776. !     XtSetArg( args[argi], name,  value ); ++argi;
  777.   
  778.   /*--Start up the toolkit.  This creates a shell widget.  Unfortunately the
  779.    *  only way the toolkit allows you to specify default application resources
  780. --- 249,256 ----
  781.   
  782.   #undef SETARG
  783.   #define SETARG(name,value) \
  784. !     DEBUG_ERROR(argi >= XtNumber(args), "main, args overrun!\n" ); \
  785. !     XtSetArg( args[argi], name,  (XtArgVal)value ); ++argi;
  786.   
  787.   /*--Start up the toolkit.  This creates a shell widget.  Unfortunately the
  788.    *  only way the toolkit allows you to specify default application resources
  789. ***************
  790. *** 323,335 ****
  791.       SETARG( XtNmaxAspectX,    1333 );
  792.       SETARG( XtNmaxAspectY,    1000 );
  793.       SETARG( XtNgeometry,    Dragon_Resources.Geometry );
  794. !     if (Dragon_Resources.Reverse_Video) {
  795. !     SETARG( XtNbackground, BlackPixelOfScreen(XtScreen(Dragon)) );
  796. !     SETARG( XtNforeground, WhitePixelOfScreen(XtScreen(Dragon)) );
  797. !     } else {
  798. !     SETARG( XtNforeground, BlackPixelOfScreen(XtScreen(Dragon)) );
  799. !     SETARG( XtNbackground, WhitePixelOfScreen(XtScreen(Dragon)) );
  800. !     }
  801.   
  802.       SETARG( XtNallowShellResize, TRUE );
  803.       SETARG( XtNinput,         TRUE );
  804. --- 301,308 ----
  805.       SETARG( XtNmaxAspectX,    1333 );
  806.       SETARG( XtNmaxAspectY,    1000 );
  807.       SETARG( XtNgeometry,    Dragon_Resources.Geometry );
  808. !     SETARG( XtNforeground, Dragon_Resources.Foreground );
  809. !     SETARG( XtNbackground, Dragon_Resources.Background );
  810.   
  811.       SETARG( XtNallowShellResize, TRUE );
  812.       SETARG( XtNinput,         TRUE );
  813. ***************
  814. *** 352,358 ****
  815.       } else if (strcmp( Dragon_Resources.Tile_Sides, "gray" ) == 0) {
  816.       Tile_Control |= BLACKSIDE | GRAYSIDE;
  817.       } else if (strcmp( Dragon_Resources.Tile_Sides, "line" ) != 0) {
  818. !     fprintf(stderr,"-side option not given line, gray, or black value.\n");
  819.       }
  820.   
  821.   /*--Create the board that we will be using; realize it too. */
  822. --- 325,332 ----
  823.       } else if (strcmp( Dragon_Resources.Tile_Sides, "gray" ) == 0) {
  824.       Tile_Control |= BLACKSIDE | GRAYSIDE;
  825.       } else if (strcmp( Dragon_Resources.Tile_Sides, "line" ) != 0) {
  826. !     (void)fprintf( stderr,
  827. !                "-side option not given line, gray, or black value.\n");
  828.       }
  829.   
  830.   /*--Create the board that we will be using; realize it too. */
  831. ***************
  832. *** 368,378 ****
  833.   /*--Now make it all appear in front of the user. */
  834.   
  835.       {    Pixmap    pix;
  836. !     pix = XCreateTile( XtDisplay(Board), XtWindow(Board),
  837. !                background_bits, background_width,
  838. !                background_height);
  839. !     if (pix == None) {
  840. !         fprintf( stderr, "Can't allocate background pixmap.\n" );
  841.           exit(1);
  842.       }
  843.       XSetWindowBackgroundPixmap( XtDisplay(Board), XtWindow(Board), pix );
  844. --- 342,356 ----
  845.   /*--Now make it all appear in front of the user. */
  846.   
  847.       {    Pixmap    pix;
  848. !     pix =
  849. !       XCreatePixmapFromBitmapData
  850. !         ( XtDisplay(Board), XtWindow(Board),
  851. !           background_bits, background_width, background_height,
  852. !           Dragon_Resources.Foreground, Dragon_Resources.Background,
  853. !           DefaultDepthOfScreen(XtScreen(Board)) );
  854. !                       
  855. !     if (pix == (Pixmap)0L) {
  856. !         (void)fprintf( stderr, "Can't allocate background pixmap.\n" );
  857.           exit(1);
  858.       }
  859.       XSetWindowBackgroundPixmap( XtDisplay(Board), XtWindow(Board), pix );
  860. ***************
  861. *** 384,399 ****
  862.       XtMainLoop();
  863.   
  864.   } /* main */
  865. - 
  866. - #if 0
  867. - */* print out the name of a widget; NOTE: no \n printed so printout is not
  868. - * * flushed until our caller does one. */
  869. - *
  870. - *void spit(w)
  871. - *     Widget    w;
  872. - *{
  873. - *    if (w == NULL) return;
  874. - *    spit( w->core.parent );
  875. - *    fprintf( stderr, ".%s", w->core.name );
  876. - *}
  877. - #endif /* 0 */
  878. --- 362,364 ----
  879. *** ../dragon/main.h    Tue May 23 00:04:05 1989
  880. --- main.h    Mon May 22 23:55:44 1989
  881. ***************
  882. *** 15,22 ****
  883. --- 15,24 ----
  884.   #include <X11/Simple.h>
  885.   #include <X11/StringDefs.h>
  886.   
  887. + #ifndef TRUE
  888.   #define TRUE    1
  889.   #define FALSE    0
  890. + #endif
  891.   
  892.   #ifdef _MAIN_C_
  893.   #define VAR(A)        A
  894. ***************
  895. *** 32,37 ****
  896. --- 34,41 ----
  897.   ******************************************************************************/
  898.   
  899.   typedef struct _Dragon_Resources_Rec{
  900. +     Pixel        Foreground;        /* Default foreground color */
  901. +     Pixel        Background;        /* Default background color */
  902.       Cursor        Cursor;            /* Name of cursor to use */
  903.       Boolean        Debug;            /* Debug printouts */
  904.       int            Double_Click_Time;    /* Time (ms) between clicks */
  905. ***************
  906. *** 40,61 ****
  907.       Boolean        Iconic;            /* Do we start as an icon? */
  908.       String        Icon_Name;        /* Name for the icon */
  909.       Boolean        Reverse_Video;        /* Do all in reverse? */
  910.       Boolean        Tile_Shadows;        /* Want shadows? */
  911.       String        Tile_Sides;        /* What side type? */
  912.   } Dragon_Resources_Rec, *Dragon_Resources_Ptr;
  913.   
  914.   #define DEBUG_CALL(Name) \
  915.     if (Dragon_Resources.Debug) { \
  916. !     fprintf( stderr, "Name call\n" ); fflush(stderr); \
  917.     }
  918.   #define DEBUG_RETURN(Name) \
  919.     if (Dragon_Resources.Debug) { \
  920. !     fprintf( stderr, "Name return\n" ); fflush(stderr); \
  921.     }
  922.   #define DEBUG_OTHER(Name,Other) \
  923.     if (Dragon_Resources.Debug) { \
  924. !     fprintf( stderr, "Name Other\n" ); fflush(stderr); \
  925.     }
  926.   
  927.   /******************************************************************************
  928.   * Bitmap/Image Initialization Structure
  929. --- 44,75 ----
  930.       Boolean        Iconic;            /* Do we start as an icon? */
  931.       String        Icon_Name;        /* Name for the icon */
  932.       Boolean        Reverse_Video;        /* Do all in reverse? */
  933. +     Boolean        Sticky_Tile;        /* Is first tile sticky? */
  934.       Boolean        Tile_Shadows;        /* Want shadows? */
  935.       String        Tile_Sides;        /* What side type? */
  936.   } Dragon_Resources_Rec, *Dragon_Resources_Ptr;
  937.   
  938. + #ifdef WANTDEBUG
  939.   #define DEBUG_CALL(Name) \
  940.     if (Dragon_Resources.Debug) { \
  941. !     (void)fprintf( stderr, "Name call\n" ); (void)fflush(stderr); \
  942.     }
  943.   #define DEBUG_RETURN(Name) \
  944.     if (Dragon_Resources.Debug) { \
  945. !     (void)fprintf( stderr, "Name return\n" ); (void)fflush(stderr); \
  946.     }
  947.   #define DEBUG_OTHER(Name,Other) \
  948.     if (Dragon_Resources.Debug) { \
  949. !     (void)fprintf( stderr, "Name Other\n" ); (void)fflush(stderr); \
  950.     }
  951. + #define DEBUG_ERROR(Test,Msg) \
  952. +   if (Test) { (void)fprintf(stderr,Msg); (void)fflush(stderr); }
  953. + #else
  954. + #define DEBUG_CALL(Name)
  955. + #define DEBUG_RETURN(Name)
  956. + #define DEBUG_OTHER(Name,Other)
  957. + #define DEBUG_ERROR(Test,Msg)
  958. + #endif /* WANTDEBUG */
  959.   
  960.   /******************************************************************************
  961.   * Bitmap/Image Initialization Structure
  962. ***************
  963. *** 96,98 ****
  964. --- 110,116 ----
  965.   VAR( GC               Over_GC );        /* fg=blk, bg=wht, fcn=or */
  966.   VAR( GC               Reverse_GC );    /* fg=wht, bg=blk, fcn=copy */
  967.   VAR( GC               Xor_GC );        /* fg=blk, bg=wht, fcn=xor */
  968. + 
  969. + #undef VAR
  970. + #undef VARI
  971. + 
  972. *** ../dragon/tile.c    Tue May 23 00:03:57 1989
  973. --- tile.c    Mon May 22 23:55:46 1989
  974. ***************
  975. *** 122,129 ****
  976.   /*--Make sure that our caller is rational. */
  977.   
  978.       if (size < 1 || size > 5) {
  979. !     fprintf( stderr, "Bad size given to Configure_Tiles in tile.c [%d].\n",
  980. !          size );
  981.       size = 1;
  982.       }
  983.   
  984. --- 122,130 ----
  985.   /*--Make sure that our caller is rational. */
  986.   
  987.       if (size < 1 || size > 5) {
  988. !     (void)fprintf( stderr,
  989. !                "Bad size given to Configure_Tiles in tile.c [%d].\n",
  990. !                size );
  991.       size = 1;
  992.       }
  993.   
  994. ***************
  995. *** 201,207 ****
  996.   * Called to draw the number in the upper right corner of a numbered tile.
  997.   ******************************************************************************/
  998.   {
  999. !     XPutImage( XtDisplay(Board), XtWindow(Board), Over_GC, image,
  1000.              0, 0, x + Number_X, y + Number_Y,
  1001.              (unsigned int)image->width, (unsigned int)image->height );
  1002.   } /* Draw_Number */
  1003. --- 202,208 ----
  1004.   * Called to draw the number in the upper right corner of a numbered tile.
  1005.   ******************************************************************************/
  1006.   {
  1007. !     XPutImage( XtDisplay(Board), XtWindow(Board), Xor_GC, image,
  1008.              0, 0, x + Number_X, y + Number_Y,
  1009.              (unsigned int)image->width, (unsigned int)image->height );
  1010.   } /* Draw_Number */
  1011. No differences encountered
  1012.